import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadPool {
    public ThreadPool(int n) {
        for(int i=0;i<n;i++){
            Thread thread=new Thread(()->{
                while(true) {
                    try {
                        Runnable runnable = queue.take();
                        runnable.run();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }

            });
            thread.start();


        }
    }

    private BlockingQueue<Runnable> queue=new LinkedBlockingQueue<>();

    public void submit(Runnable runnable){

        try {
            queue.put(runnable);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        //11111111112222444
        //444
        //CAS为：compared and swap
        //3444
        //77777
        //是内存与寄存器的比较和交换
        //CAS为原子的操作，所以它天生就是线程安全的，
        //就是CPU的一条指令，
        //假设一种情况，去ATM取钱，假设我有1000元，此时要取出800元，
        //但此时的机器卡了，我就多按了几下，但在此时课我的好朋友给我有转了800元，那们因为机器看到我的钱
        //有大于800元，所以就又进行了一次取钱的操作
        //那就出现bug了

        //CAS的应用场景有两个：1.实现原子类
        //线程池中的那个就可以体现出那个工厂的模式，就是在普通方法中构造对象，代替构造方法，这个模式也是设计模式的一种
        //设计模式有两种，一种为单例模式，一种为工厂模式，可以把设计模式看成一个棋谱，按照棋谱写，最后也不会太差
        //

        ReentrantLock reentrantLock=new ReentrantLock(true);
        //这个也是锁，这个锁相比与synchronized来说，它是一个公平锁，公平锁就是先来先服务
        //这里说一下锁策略
        //1.乐观锁和悲观锁  ，乐观锁预测的锁竞争是比较小的，悲观锁是预测锁竞争是比较大的
        //2.轻量级锁和重量级锁  轻量级锁的加锁和解锁的开销比较小，重量级锁的加锁和解锁的开销比较大
        //3.自旋锁和挂起等待锁  自旋锁是典型的轻量级锁，
        //自旋锁举个例子：我有一个朋友，他以前追女生的一个故事，然后我觉得这个例子贼贴切
        //他当时给他的女神表白，但是女生给他说，我已经有男朋友了，然后他还是很喜欢他，就跟舔狗一样，每次都跟他说早安，晚安，午安
        //最后那个女神分手了，最后那个女神就跟他好上了，这就是自选，一直去看看他的女神被释放没，一旦释放了他就可以对女神上锁
        //但是这个自旋锁，它是一直会占用系统资源的，也不是很好
        //挂起等待锁：这个就是当男的知道女神有男朋友了，就不会去打扰她了，当女神唤醒他，他才去加锁

        //4.公平锁和非公平锁：公平锁是先来先服务的这种，先来先锁
        //非公平锁：它是都可以对资源加锁，谁加上就是谁的

        //5.互斥锁和读写锁



        //java标准库提供的线程池有七个参数：
        //1.corepoolsize（核心线程数），这个是代表包工头，
        //2.maximumsize(最大线程数），这个是包工头和普通工人
        //3.alongkeepalive（允许普通工人不干活的最大时间），超过这个时间，就被炒鱿鱼
        //4.time   时间单位
        //5 阻塞队列  用来存放任务
        //6.创建线程   用来创建线程
        //7.拒绝策略
        //拒绝策略有四种方式：1.若任务队列满了，你来了一个新任务，那我就直接抛出异常
        //2.谁加的这个任务，谁负责
        //3.做新的任务
        //4.丢弃新的任务
    }

    public static void main1(String[] args) throws InterruptedException {
        //ZHESHI1
        ThreadPool threadPool=new ThreadPool(10);
        for (int i = 0; i < 1000; i++) {
            int n=i;
            threadPool.submit(new Runnable() {
                @Override
                public void run() {

                    System.out.println("hello"+n);
                    //这里会有一个变量的捕获，为啥不用i,因为i是属于主线程，当主线程
                    //结束后i就被销毁了，所以就的拷贝一份到线程中，这样就不会找不到了
                    //这里非常好
                }
            });

        }


    }
}